package com.example.furniture.service.impl;

import com.example.furniture.entity.Category;
import com.example.furniture.mapper.CategoryMapper;
import com.example.furniture.service.CategoryService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

/**
 * 分类服务实现类
 * 提供家具分类相关的业务逻辑处理
 * 
 * @author 家具商城系统
 * @version 1.0
 * @since 2024-01-01
 */
@Service
@Transactional
public class CategoryServiceImpl implements CategoryService {

    private static final Logger logger = LoggerFactory.getLogger(CategoryServiceImpl.class);
    private final CategoryMapper categoryMapper;

    /**
     * 构造函数，注入分类数据访问层
     * 
     * @param categoryMapper 分类数据访问层实例
     */
    public CategoryServiceImpl(CategoryMapper categoryMapper) {
        this.categoryMapper = categoryMapper;
    }

    /**
     * 根据ID获取分类信息
     * 
     * @param id 分类ID
     * @return 分类信息，如果不存在返回null
     */
    @Override
    public Category getById(Long id) {
        logger.debug("根据ID获取分类信息: {}", id);
        try {
            Category category = categoryMapper.selectById(id);
            if (category != null) {
                logger.debug("成功获取分类信息: {}", category.getName());
            } else {
                logger.debug("分类不存在: {}", id);
            }
            return category;
        } catch (Exception e) {
            logger.error("获取分类信息失败，ID: {}", id, e);
            throw new RuntimeException("获取分类信息失败", e);
        }
    }

    /**
     * 获取所有分类列表
     * 
     * @return 分类列表
     */
    @Override
    public List<Category> listAll() {
        logger.debug("获取所有分类列表");
        try {
            List<Category> categories = categoryMapper.selectAll();
            logger.debug("成功获取分类列表，共{}条记录", categories.size());
            return categories;
        } catch (Exception e) {
            logger.error("获取分类列表失败", e);
            throw new RuntimeException("获取分类列表失败", e);
        }
    }

    /**
     * 创建新分类
     * 
     * @param category 分类信息
     * @return 创建的分类信息（包含生成的ID）
     */
    @Override
    public Category create(Category category) {
        logger.debug("创建新分类: {}", category.getName());
        try {
            // 验证分类信息
            validateCategory(category);
            
            // 检查分类名称是否已存在
            if (isCategoryNameExists(category.getName())) {
                logger.warn("分类名称已存在: {}", category.getName());
                throw new RuntimeException("分类名称已存在");
            }
            
            categoryMapper.insert(category);
            logger.info("分类创建成功，ID: {}, 名称: {}", category.getId(), category.getName());
            return category;
        } catch (Exception e) {
            logger.error("创建分类失败: {}", category.getName(), e);
            throw new RuntimeException("创建分类失败", e);
        }
    }

    /**
     * 更新分类信息
     * 
     * @param id 分类ID
     * @param category 更新的分类信息
     * @return 更新后的分类信息
     */
    @Override
    public Category update(Long id, Category category) {
        logger.debug("更新分类信息，ID: {}", id);
        try {
            // 检查分类是否存在
            Category existingCategory = categoryMapper.selectById(id);
            if (existingCategory == null) {
                logger.warn("分类不存在，无法更新，ID: {}", id);
                throw new RuntimeException("分类不存在");
            }
            
            // 验证分类信息
            validateCategory(category);
            
            // 检查分类名称是否被其他分类使用
            if (!existingCategory.getName().equals(category.getName()) && isCategoryNameExists(category.getName())) {
                logger.warn("分类名称已被其他分类使用: {}", category.getName());
                throw new RuntimeException("分类名称已被其他分类使用");
            }
            
            category.setId(id);
            categoryMapper.update(category);
            Category updatedCategory = categoryMapper.selectById(id);
            logger.info("分类更新成功，ID: {}, 名称: {}", id, updatedCategory.getName());
            return updatedCategory;
        } catch (Exception e) {
            logger.error("更新分类失败，ID: {}", id, e);
            throw new RuntimeException("更新分类失败", e);
        }
    }

    /**
     * 删除分类
     * 
     * @param id 分类ID
     */
    @Override
    public void delete(Long id) {
        logger.debug("删除分类，ID: {}", id);
        try {
            // 检查分类是否存在
            Category existingCategory = categoryMapper.selectById(id);
            if (existingCategory == null) {
                logger.warn("分类不存在，无法删除，ID: {}", id);
                throw new RuntimeException("分类不存在");
            }
            
            // 检查是否有家具使用此分类
            if (hasFurnitureInCategory(id)) {
                logger.warn("分类下还有家具，无法删除，ID: {}", id);
                throw new RuntimeException("分类下还有家具，无法删除");
            }
            
            categoryMapper.deleteById(id);
            logger.info("分类删除成功，ID: {}", id);
        } catch (Exception e) {
            logger.error("删除分类失败，ID: {}", id, e);
            throw new RuntimeException("删除分类失败", e);
        }
    }

    /**
     * 验证分类信息
     * 
     * @param category 分类信息
     */
    private void validateCategory(Category category) {
        if (category.getName() == null || category.getName().trim().isEmpty()) {
            throw new RuntimeException("分类名称不能为空");
        }
        
        if (category.getName().length() > 50) {
            throw new RuntimeException("分类名称不能超过50个字符");
        }
        
        logger.debug("分类信息验证通过: {}", category.getName());
    }

    /**
     * 检查分类名称是否已存在
     * 
     * @param name 分类名称
     * @return 是否存在
     */
    private boolean isCategoryNameExists(String name) {
        // 这里可以添加更复杂的分类名称重复检查逻辑
        // 目前简化处理，实际项目中应该查询数据库
        return false;
    }

    /**
     * 检查分类下是否有家具
     * 
     * @param categoryId 分类ID
     * @return 是否有家具
     */
    private boolean hasFurnitureInCategory(Long categoryId) {
        // 这里可以添加检查分类下是否有家具的逻辑
        // 目前简化处理，实际项目中应该查询家具表
        return false;
    }
}


